$.widget("dg.fancySlide", {
    options: {
        url: "",
        type:"post",
        async:true,
        autoPlay: true,
		position:"",
        timer: 2000,
		afterTransition:null,
        width: 1200,
		_width:1200,
        height: 300,
        arrowsWidth: 0,
        effect: "slide",
		easing:"easeInOutQuad",
		thumb:false,
		duration:600,
        bannerItems: []//[{href:"",src:"",alt:""}]
    },
    loopFlag: 0,
	currentSlide:0,
	lastSlide: 0,
	loaded: 0,
	args:[],
	loadComplete:false,
	effectTimeout:0,
	loadCallBack: function (viewport, nav, content, arrows) {
	    var that = this;
	    var ops = that.options;
	    viewport.children().append([content, arrows]);
	    if (ops.autoPlay) {
	        that.loopFlag = setTimeout($.proxy(that.setAutoPlay, that), ops.timer);
	        that.element.on({
	            "mouseover": function () {
	                clearTimeout(that.loopFlag);
	            },
	            "mouseleave": function () {
	                that.loopFlag = setTimeout($.proxy(that.setAutoPlay, that), ops.timer)
	            }
	        })
	    }
	    that.loaded = 1;
		that.args[4].remove();
	},
	getTarget:function(dir){
		var that = this;
		var rs = 0;
		if(dir == "next"){
			rs = (that.currentSlide == that.lastSlide) ? 0 : ++that.currentSlide;
		}else{
			rs = (that.currentSlide == 0) ? that.lastSlide : --that.currentSlide;
		}
		return that.currentSlide = rs;
	},
    setAutoPlay: function () {
        var that = this;
        var ele = that.element;
        var ops = this.options;
        var next = $(ele).find(".ui-banner-nav li").eq(that.getTarget("next"));
        
		that["simple" + ops.effect](next);
		
		that.loopFlag = setTimeout($.proxy(that.setAutoPlay,that),ops.timer);
    },
	getLayout:function(effect){
		switch(effect){
			case "slide":
			return "tile";//平铺
			break;
			case "fade":
			return "pile";//堆叠
			break;
		}
	},
    generate:function(){
        var that = this;
        var wrapper = this.element;
        var ops = that.options;
        var viewport, nav, content, contentPH, arrows;
        if($(window).width() >500)
		{
            ops._width = ops.width > $(window).width() ? $(window).width() : ops.width;
        }else{
            ops._width = ops.width;
        }
        if (ops.bannerItems.length == 0) {
            if (typeof (ops.url) == "string" && ops.url.length !== 0) {
                $.ajax({
                    url: ops.url,
                    type: ops.type,
                    async: ops.async,
                    dataType: "json",
                    success: function (data) {
                        ops.bannerItems = data;
                    }
                })
                if (ops.bannerItems.length == undefined || ops.bannerItems.length == 0) return;
            } else {
                return;
            }
        }
        that.lastSlide = ops.bannerItems.length - 1;//load banner count
		var navPos = ops.position;
        nav = $("<ul>", {
			"class": "ui-banner-nav",
			style: navPos,
            html: $.map(ops.bannerItems, function (p, i) {
                return $("<li>", {
					title:p.title == undefined ? "" : p.title,
                    on: {
                        "mouseenter": function () {
                            if (!that.loaded) {
                                that.loadCallBack(viewport, nav, content, arrows);
                            }
                            var $li = $(this);
                            that.currentSlide = nav.find("li").index($li);
                            that["simple" + ops.effect]($li);
                        }
                    },
                    html: $("<a>", {
						html:ops.thumb/*使用缩略图作为导航*/ ? $("<img>",{src:p.thumb_src?p.thumb_src:p.src}) : i+1
                    })
                });
            })
        });//banner navigator
        contentPH = $("<div>", {
            "class": "ui-banner-contentPH",
            style: "position:absolute;width:" + ops._width + "px;height:" + ops.height + "px",
            html: $("<img>", {
                src: ops.bannerItems[0].src,
                style: "width:" + ops.width + "px;height:" + ops.height + "px;position:absolute;left:50%;margin-left:-"+ops.width/2+"px;",
                width: ops.width,
                style: "display:none",
                height: ops.height
            })
        });//首焦加载第一帧
        content = $("<div>", {
            "class": "ui-banner-content",
            style: that.getLayout(ops.effect) == "tile" ? 
				"position:absolute;width:" + ops.bannerItems.length * ops._width + "px;height:" + ops.height + "px" :
                "position:absolute;width:" + ops._width + "px;height:" + ops.height + "px",
            html: $.map(ops.bannerItems, function (p, i) {
                var $img = $("<img>", $.extend(i <= 1 ? {} : { "data-lazysrc": p.src }, {
                    alt: p.alt,
                    src: i <= 1 ? p.src : "",//lazyload
                    style: "width:" + ops.width + "px;height:" + ops.height + "px;position:absolute;left:50%;margin-left:-"+ops.width/2+"px;"+(i == 0 ? "" : "display:none;"),
                    width: ops.width,
                    height: ops.height
                }));
                return $("<div>", {
                    "class": "ui-banner-item",
                    style: "width:" + ops._width + "px;height:" + ops.height + "px;" + (that.getLayout(ops.effect) == "tile" ? "" : "position:absolute;z-index:" + (i == 0 ? "2" : "1;display:none")),
                    html: $("<a>", {
						name:p.name == undefined ? "" :p.name,
                        href: p.href,
                        target: p.target == undefined ? "_blank" : p.target,
                        html: $img,
                        title: p.title == undefined ? "" : p.title
                    })
                })
            })
        });
        arrows = $("<div>", {
            "class": "ui-banner-arrows",
            style: "width:" + ops.arrowsWidth + "px",
            html: [$("<a>", {
                "class": "prev",// ui-banner-btn",
                html: "&lt;",
                on: {
                    click: function () {
                        var prev = nav.find("li").eq(that.getTarget("prev"))
                        that["simple" + ops.effect](prev);
                    },
                    mouseenter: function () {
                        $(this).stop().animate({
                            width: "50px",
                            opacity: "0.7"
                        }, 300)
                    },
                    mouseleave: function () {
                        $(this).stop().animate({
                            width: "30px",
                            opacity: "0.4"
                        }, 300)
                    }
                }
            }),
            $("<a>", {
                "class": "next",// ui-banner-btn",
                html: "&gt;",
                on: {
                    click: function () {
                        var next = nav.find("li").eq(that.getTarget("next"))
                        that["simple" + ops.effect](next);
                    },
                    mouseenter: function () {
                        $(this).stop().animate({
                            width: "50px",
                            opacity: "0.7"
                        }, 300)
                    },
                    mouseleave: function () {
                        $(this).stop().animate({
                            width: "30px",
                            opacity: "0.4"
                        }, 300)
                    }
                }
            })]
        })
        
		var mainHtml = [contentPH];
		
		var preview = wrapper.find("a.preview");
		if(preview.length){ 
			mainHtml.splice(0,1);
		}else{
			contentPH.find("img").load(function () {
				nav.find("li:first").addClass("ui-select");
				$(this).fadeIn({
					duration: ops.duration,
					easing: "swing"
				});
				that.args = [].concat([viewport, nav, content, arrows, contentPH]);
				that.readyLoad();
			})
		}
        viewport = $("<div>", {
            "class": "ui-banner-viewport ui-banner-clearfix",
            style: "width:" + ops._width + "px;",
            html: $("<div>", {
                style: "height:" + that.options.height + "px",
                html: mainHtml
            })
        })
        wrapper.addClass("ui-banner").append(viewport);
        wrapper.addClass("ui-banner").append(nav);
		if(preview.length){
			nav.find("li:first").addClass("ui-select");
			that.args = [].concat([viewport, nav, content, arrows, preview]);
			that.readyLoad();
		}
    },
    _create: function () {
        $(window).load(function () {
            $(this).data("loaded", true);
        });
        var that = this, ops = that.options;
        if (ops.bannerItems.length == 0) {
            if (typeof (ops.url) == "string" && ops.url.length !== 0) {
                $.ajax({
                    url: ops.url,
                    type: ops.type,
                    async: ops.async,
                    dataType: "json",
                    success: function (data) {
                        ops.bannerItems = data;
                        if (ops.bannerItems.length == undefined || ops.bannerItems.length == 0) return;
                        that.generate();
                    }
                })
            }
            return;
        }
        that.generate();
    },
	readyLoad:function(){
		var that = this;
		if($(window).data("loaded") == true){
			if (that.loaded) return;
			that.loadCallBack(that.args[0], that.args[1], that.args[2], that.args[3]);
		}else{
			setTimeout($.proxy(that.readyLoad,that),1000);
		}
	},
	preLoad:function($item){
		var that = this;
		var $img = $item.find("img");
		var isLoad = $img.data("lazysrc") == undefined;
		if(isLoad && $img.css("display") !== "none"){
			return;
		}
		else if(isLoad && $img.css("display") == "none"){
			$img.fadeIn(that.options.duration);
		}else{
			$img.load(function () {
				$(this).fadeIn(that.options.duration);
			})
			.attr("src", $img.data("lazysrc"))
			.removeData("lazysrc").removeAttr("data-lazysrc");
		}
	},
	loadCheck:function($container,idx){
		var calArr = $.map($container.find(".ui-banner-item").find("img"),function(){
			return ($(this).data("lazysrc") == undefined);
		})
		if(eval(calArr.join(" && "))){
			this.loadComplete = true;
		}
		var $img = $container.find(".ui-banner-item").eq(idx+1).find("img");
		if($img.data("lazysrc") !== undefined){
			$img.attr("src",$img.data("lazysrc")).removeData("lazysrc").removeAttr("data-lazysrc");
		}
	},
    simpleslide: function (trigger) {
        var that = this;
        var ele = that.element;
        var borthers = trigger.closest("ul").children();
		var currIdx = borthers.index(borthers.filter(".ui-select"));
		var targetIdx = borthers.index(trigger);
        borthers.removeClass("ui-select");
        trigger.addClass("ui-select");
		clearTimeout(that.effectTimeout);
		that.effectTimeout = setTimeout(function(){
			var grandfa = $(ele).find(".ui-banner-content");
			var target = grandfa.find(".ui-banner-item").eq(targetIdx);
			that.preLoad(target);
			if(currIdx == that.options.bannerItems.length - 1 && targetIdx == 0){//最后一帧切换时 平滑过度到第一帧
				var targetClone = target.clone().addClass("ui-tile-clone").css({position:"absolute",top:0,left:"100%"}).insertAfter(grandfa);
				targetClone.animate({left: [0, that.options.easing]}, that.options.duration);
				grandfa.stop().animate({ left: [-grandfa.width() , that.options.easing] }, that.options.duration,function(){
					if($.isFunction(that.options.afterTransition)){
						that.options.afterTransition(currIdx,targetIdx);
					}
					grandfa.css("left",0);
					targetClone.remove();
				});
			}else{
				grandfa.stop().animate({ left: [-target.position().left, that.options.easing] }, that.options.duration,function(){
					if($.isFunction(that.options.afterTransition)){
						that.options.afterTransition(currIdx,targetIdx);
					}
				});
			}
			if(!that.loadComplete) that.loadCheck(grandfa,targetIdx);
		},200);
    },
    simplefade: function (trigger) {
        var that = this;
        var ele = that.element;
        var borthers = trigger.closest("ul").children();
        var grandfa = $(ele).find(".ui-banner-content");
        var currIdx = borthers.index(borthers.filter(".ui-select"));
        var curr = grandfa.find(".ui-banner-item").eq(currIdx);
		borthers.removeClass("ui-select");
		trigger.addClass("ui-select");
		var targetIdx = borthers.index(trigger);
		var target = grandfa.find(".ui-banner-item").eq(targetIdx);
		if (currIdx == targetIdx) return;
		that.preLoad(target);
		target.fadeIn(0);
		curr.stop(true, true).fadeOut({
			duration:that.options.duration,
			complete:function () {
				target.css("z-index", 2);
				curr.css("z-index", 1);
				if($.isFunction(that.options.afterTransition)){
					that.options.afterTransition(currIdx,targetIdx);
				}
			},
			easing:that.options.easing
		});
		if(!that.loadComplete) that.loadCheck(grandfa,targetIdx);
    }
})

/*!
 * jQuery UI Effects 1.9.2
 * http://jqueryui.com
 *
 * Copyright 2012 jQuery Foundation and other contributors
 * Released under the MIT license.
 * http://jquery.org/license
 *
 * http://api.jqueryui.com/category/effects-core/
 */
;(jQuery.effects || (function($, undefined) {

var backCompat = $.uiBackCompat !== false,
    // prefix used for storing data on .data()
    dataSpace = "ui-effects-";

$.effects = {
    effect: {}
};

/*!
 * jQuery Color Animations v2.0.0
 * http://jquery.com/
 *
 * Copyright 2012 jQuery Foundation and other contributors
 * Released under the MIT license.
 * http://jquery.org/license
 *
 * Date: Mon Aug 13 13:41:02 2012 -0500
 */
(function( jQuery, undefined ) {

    var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor".split(" "),

    // plusequals test for += 100 -= 100
    rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
    // a set of RE's that can match strings and generate color tuples.
    stringParsers = [{
            re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,
            parse: function( execResult ) {
                return [
                    execResult[ 1 ],
                    execResult[ 2 ],
                    execResult[ 3 ],
                    execResult[ 4 ]
                ];
            }
        }, {
            re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,
            parse: function( execResult ) {
                return [
                    execResult[ 1 ] * 2.55,
                    execResult[ 2 ] * 2.55,
                    execResult[ 3 ] * 2.55,
                    execResult[ 4 ]
                ];
            }
        }, {
            // this regex ignores A-F because it's compared against an already lowercased string
            re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
            parse: function( execResult ) {
                return [
                    parseInt( execResult[ 1 ], 16 ),
                    parseInt( execResult[ 2 ], 16 ),
                    parseInt( execResult[ 3 ], 16 )
                ];
            }
        }, {
            // this regex ignores A-F because it's compared against an already lowercased string
            re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
            parse: function( execResult ) {
                return [
                    parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
                    parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
                    parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
                ];
            }
        }, {
            re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,
            space: "hsla",
            parse: function( execResult ) {
                return [
                    execResult[ 1 ],
                    execResult[ 2 ] / 100,
                    execResult[ 3 ] / 100,
                    execResult[ 4 ]
                ];
            }
        }],

    // jQuery.Color( )
    color = jQuery.Color = function( color, green, blue, alpha ) {
        return new jQuery.Color.fn.parse( color, green, blue, alpha );
    },
    spaces = {
        rgba: {
            props: {
                red: {
                    idx: 0,
                    type: "byte"
                },
                green: {
                    idx: 1,
                    type: "byte"
                },
                blue: {
                    idx: 2,
                    type: "byte"
                }
            }
        },

        hsla: {
            props: {
                hue: {
                    idx: 0,
                    type: "degrees"
                },
                saturation: {
                    idx: 1,
                    type: "percent"
                },
                lightness: {
                    idx: 2,
                    type: "percent"
                }
            }
        }
    },
    propTypes = {
        "byte": {
            floor: true,
            max: 255
        },
        "percent": {
            max: 1
        },
        "degrees": {
            mod: 360,
            floor: true
        }
    },
    support = color.support = {},

    // element for support tests
    supportElem = jQuery( "<p>" )[ 0 ],

    // colors = jQuery.Color.names
    colors,

    // local aliases of functions called often
    each = jQuery.each;

// determine rgba support immediately
supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;

// define cache name and alpha properties
// for rgba and hsla spaces
each( spaces, function( spaceName, space ) {
    space.cache = "_" + spaceName;
    space.props.alpha = {
        idx: 3,
        type: "percent",
        def: 1
    };
});

function clamp( value, prop, allowEmpty ) {
    var type = propTypes[ prop.type ] || {};

    if ( value == null ) {
        return (allowEmpty || !prop.def) ? null : prop.def;
    }

    // ~~ is an short way of doing floor for positive numbers
    value = type.floor ? ~~value : parseFloat( value );

    // IE will pass in empty strings as value for alpha,
    // which will hit this case
    if ( isNaN( value ) ) {
        return prop.def;
    }

    if ( type.mod ) {
        // we add mod before modding to make sure that negatives values
        // get converted properly: -10 -> 350
        return (value + type.mod) % type.mod;
    }

    // for now all property types without mod have min and max
    return 0 > value ? 0 : type.max < value ? type.max : value;
}

function stringParse( string ) {
    var inst = color(),
        rgba = inst._rgba = [];

    string = string.toLowerCase();

    each( stringParsers, function( i, parser ) {
        var parsed,
            match = parser.re.exec( string ),
            values = match && parser.parse( match ),
            spaceName = parser.space || "rgba";

        if ( values ) {
            parsed = inst[ spaceName ]( values );

            // if this was an rgba parse the assignment might happen twice
            // oh well....
            inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
            rgba = inst._rgba = parsed._rgba;

            // exit each( stringParsers ) here because we matched
            return false;
        }
    });

    // Found a stringParser that handled it
    if ( rgba.length ) {

        // if this came from a parsed string, force "transparent" when alpha is 0
        // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
        if ( rgba.join() === "0,0,0,0" ) {
            jQuery.extend( rgba, colors.transparent );
        }
        return inst;
    }

    // named colors
    return colors[ string ];
}

color.fn = jQuery.extend( color.prototype, {
    parse: function( red, green, blue, alpha ) {
        if ( red === undefined ) {
            this._rgba = [ null, null, null, null ];
            return this;
        }
        if ( red.jquery || red.nodeType ) {
            red = jQuery( red ).css( green );
            green = undefined;
        }

        var inst = this,
            type = jQuery.type( red ),
            rgba = this._rgba = [];

        // more than 1 argument specified - assume ( red, green, blue, alpha )
        if ( green !== undefined ) {
            red = [ red, green, blue, alpha ];
            type = "array";
        }

        if ( type === "string" ) {
            return this.parse( stringParse( red ) || colors._default );
        }

        if ( type === "array" ) {
            each( spaces.rgba.props, function( key, prop ) {
                rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
            });
            return this;
        }

        if ( type === "object" ) {
            if ( red instanceof color ) {
                each( spaces, function( spaceName, space ) {
                    if ( red[ space.cache ] ) {
                        inst[ space.cache ] = red[ space.cache ].slice();
                    }
                });
            } else {
                each( spaces, function( spaceName, space ) {
                    var cache = space.cache;
                    each( space.props, function( key, prop ) {

                        // if the cache doesn't exist, and we know how to convert
                        if ( !inst[ cache ] && space.to ) {

                            // if the value was null, we don't need to copy it
                            // if the key was alpha, we don't need to copy it either
                            if ( key === "alpha" || red[ key ] == null ) {
                                return;
                            }
                            inst[ cache ] = space.to( inst._rgba );
                        }

                        // this is the only case where we allow nulls for ALL properties.
                        // call clamp with alwaysAllowEmpty
                        inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
                    });

                    // everything defined but alpha?
                    if ( inst[ cache ] && $.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
                        // use the default of 1
                        inst[ cache ][ 3 ] = 1;
                        if ( space.from ) {
                            inst._rgba = space.from( inst[ cache ] );
                        }
                    }
                });
            }
            return this;
        }
    },
    is: function( compare ) {
        var is = color( compare ),
            same = true,
            inst = this;

        each( spaces, function( _, space ) {
            var localCache,
                isCache = is[ space.cache ];
            if (isCache) {
                localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
                each( space.props, function( _, prop ) {
                    if ( isCache[ prop.idx ] != null ) {
                        same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
                        return same;
                    }
                });
            }
            return same;
        });
        return same;
    },
    _space: function() {
        var used = [],
            inst = this;
        each( spaces, function( spaceName, space ) {
            if ( inst[ space.cache ] ) {
                used.push( spaceName );
            }
        });
        return used.pop();
    },
    transition: function( other, distance ) {
        var end = color( other ),
            spaceName = end._space(),
            space = spaces[ spaceName ],
            startColor = this.alpha() === 0 ? color( "transparent" ) : this,
            start = startColor[ space.cache ] || space.to( startColor._rgba ),
            result = start.slice();

        end = end[ space.cache ];
        each( space.props, function( key, prop ) {
            var index = prop.idx,
                startValue = start[ index ],
                endValue = end[ index ],
                type = propTypes[ prop.type ] || {};

            // if null, don't override start value
            if ( endValue === null ) {
                return;
            }
            // if null - use end
            if ( startValue === null ) {
                result[ index ] = endValue;
            } else {
                if ( type.mod ) {
                    if ( endValue - startValue > type.mod / 2 ) {
                        startValue += type.mod;
                    } else if ( startValue - endValue > type.mod / 2 ) {
                        startValue -= type.mod;
                    }
                }
                result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
            }
        });
        return this[ spaceName ]( result );
    },
    blend: function( opaque ) {
        // if we are already opaque - return ourself
        if ( this._rgba[ 3 ] === 1 ) {
            return this;
        }

        var rgb = this._rgba.slice(),
            a = rgb.pop(),
            blend = color( opaque )._rgba;

        return color( jQuery.map( rgb, function( v, i ) {
            return ( 1 - a ) * blend[ i ] + a * v;
        }));
    },
    toRgbaString: function() {
        var prefix = "rgba(",
            rgba = jQuery.map( this._rgba, function( v, i ) {
                return v == null ? ( i > 2 ? 1 : 0 ) : v;
            });

        if ( rgba[ 3 ] === 1 ) {
            rgba.pop();
            prefix = "rgb(";
        }

        return prefix + rgba.join() + ")";
    },
    toHslaString: function() {
        var prefix = "hsla(",
            hsla = jQuery.map( this.hsla(), function( v, i ) {
                if ( v == null ) {
                    v = i > 2 ? 1 : 0;
                }

                // catch 1 and 2
                if ( i && i < 3 ) {
                    v = Math.round( v * 100 ) + "%";
                }
                return v;
            });

        if ( hsla[ 3 ] === 1 ) {
            hsla.pop();
            prefix = "hsl(";
        }
        return prefix + hsla.join() + ")";
    },
    toHexString: function( includeAlpha ) {
        var rgba = this._rgba.slice(),
            alpha = rgba.pop();

        if ( includeAlpha ) {
            rgba.push( ~~( alpha * 255 ) );
        }

        return "#" + jQuery.map( rgba, function( v ) {

            // default to 0 when nulls exist
            v = ( v || 0 ).toString( 16 );
            return v.length === 1 ? "0" + v : v;
        }).join("");
    },
    toString: function() {
        return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
    }
});
color.fn.parse.prototype = color.fn;

// hsla conversions adapted from:
// https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021

function hue2rgb( p, q, h ) {
    h = ( h + 1 ) % 1;
    if ( h * 6 < 1 ) {
        return p + (q - p) * h * 6;
    }
    if ( h * 2 < 1) {
        return q;
    }
    if ( h * 3 < 2 ) {
        return p + (q - p) * ((2/3) - h) * 6;
    }
    return p;
}

spaces.hsla.to = function ( rgba ) {
    if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
        return [ null, null, null, rgba[ 3 ] ];
    }
    var r = rgba[ 0 ] / 255,
        g = rgba[ 1 ] / 255,
        b = rgba[ 2 ] / 255,
        a = rgba[ 3 ],
        max = Math.max( r, g, b ),
        min = Math.min( r, g, b ),
        diff = max - min,
        add = max + min,
        l = add * 0.5,
        h, s;

    if ( min === max ) {
        h = 0;
    } else if ( r === max ) {
        h = ( 60 * ( g - b ) / diff ) + 360;
    } else if ( g === max ) {
        h = ( 60 * ( b - r ) / diff ) + 120;
    } else {
        h = ( 60 * ( r - g ) / diff ) + 240;
    }

    if ( l === 0 || l === 1 ) {
        s = l;
    } else if ( l <= 0.5 ) {
        s = diff / add;
    } else {
        s = diff / ( 2 - add );
    }
    return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
};

spaces.hsla.from = function ( hsla ) {
    if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
        return [ null, null, null, hsla[ 3 ] ];
    }
    var h = hsla[ 0 ] / 360,
        s = hsla[ 1 ],
        l = hsla[ 2 ],
        a = hsla[ 3 ],
        q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
        p = 2 * l - q;

    return [
        Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
        Math.round( hue2rgb( p, q, h ) * 255 ),
        Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
        a
    ];
};


each( spaces, function( spaceName, space ) {
    var props = space.props,
        cache = space.cache,
        to = space.to,
        from = space.from;

    // makes rgba() and hsla()
    color.fn[ spaceName ] = function( value ) {

        // generate a cache for this space if it doesn't exist
        if ( to && !this[ cache ] ) {
            this[ cache ] = to( this._rgba );
        }
        if ( value === undefined ) {
            return this[ cache ].slice();
        }

        var ret,
            type = jQuery.type( value ),
            arr = ( type === "array" || type === "object" ) ? value : arguments,
            local = this[ cache ].slice();

        each( props, function( key, prop ) {
            var val = arr[ type === "object" ? key : prop.idx ];
            if ( val == null ) {
                val = local[ prop.idx ];
            }
            local[ prop.idx ] = clamp( val, prop );
        });

        if ( from ) {
            ret = color( from( local ) );
            ret[ cache ] = local;
            return ret;
        } else {
            return color( local );
        }
    };

    // makes red() green() blue() alpha() hue() saturation() lightness()
    each( props, function( key, prop ) {
        // alpha is included in more than one space
        if ( color.fn[ key ] ) {
            return;
        }
        color.fn[ key ] = function( value ) {
            var vtype = jQuery.type( value ),
                fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
                local = this[ fn ](),
                cur = local[ prop.idx ],
                match;

            if ( vtype === "undefined" ) {
                return cur;
            }

            if ( vtype === "function" ) {
                value = value.call( this, cur );
                vtype = jQuery.type( value );
            }
            if ( value == null && prop.empty ) {
                return this;
            }
            if ( vtype === "string" ) {
                match = rplusequals.exec( value );
                if ( match ) {
                    value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
                }
            }
            local[ prop.idx ] = value;
            return this[ fn ]( local );
        };
    });
});

// add .fx.step functions
each( stepHooks, function( i, hook ) {
    jQuery.cssHooks[ hook ] = {
        set: function( elem, value ) {
            var parsed, curElem,
                backgroundColor = "";

            if ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) {
                value = color( parsed || value );
                if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
                    curElem = hook === "backgroundColor" ? elem.parentNode : elem;
                    while (
                        (backgroundColor === "" || backgroundColor === "transparent") &&
                        curElem && curElem.style
                    ) {
                        try {
                            backgroundColor = jQuery.css( curElem, "backgroundColor" );
                            curElem = curElem.parentNode;
                        } catch ( e ) {
                        }
                    }

                    value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
                        backgroundColor :
                        "_default" );
                }

                value = value.toRgbaString();
            }
            try {
                elem.style[ hook ] = value;
            } catch( error ) {
                // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
            }
        }
    };
    jQuery.fx.step[ hook ] = function( fx ) {
        if ( !fx.colorInit ) {
            fx.start = color( fx.elem, hook );
            fx.end = color( fx.end );
            fx.colorInit = true;
        }
        jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
    };
});

jQuery.cssHooks.borderColor = {
    expand: function( value ) {
        var expanded = {};

        each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
            expanded[ "border" + part + "Color" ] = value;
        });
        return expanded;
    }
};

// Basic color names only.
// Usage of any of the other color names requires adding yourself or including
// jquery.color.svg-names.js.
colors = jQuery.Color.names = {
    // 4.1. Basic color keywords
    aqua: "#00ffff",
    black: "#000000",
    blue: "#0000ff",
    fuchsia: "#ff00ff",
    gray: "#808080",
    green: "#008000",
    lime: "#00ff00",
    maroon: "#800000",
    navy: "#000080",
    olive: "#808000",
    purple: "#800080",
    red: "#ff0000",
    silver: "#c0c0c0",
    teal: "#008080",
    white: "#ffffff",
    yellow: "#ffff00",

    // 4.2.3. "transparent" color keyword
    transparent: [ null, null, null, 0 ],

    _default: "#ffffff"
};

})( jQuery );



/******************************************************************************/
/****************************** CLASS ANIMATIONS ******************************/
/******************************************************************************/
(function() {

var classAnimationActions = [ "add", "remove", "toggle" ],
    shorthandStyles = {
        border: 1,
        borderBottom: 1,
        borderColor: 1,
        borderLeft: 1,
        borderRight: 1,
        borderTop: 1,
        borderWidth: 1,
        margin: 1,
        padding: 1
    };

$.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
    $.fx.step[ prop ] = function( fx ) {
        if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
            jQuery.style( fx.elem, prop, fx.end );
            fx.setAttr = true;
        }
    };
});

function getElementStyles() {
    var style = this.ownerDocument.defaultView ?
            this.ownerDocument.defaultView.getComputedStyle( this, null ) :
            this.currentStyle,
        newStyle = {},
        key,
        len;

    // webkit enumerates style porperties
    if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
        len = style.length;
        while ( len-- ) {
            key = style[ len ];
            if ( typeof style[ key ] === "string" ) {
                newStyle[ $.camelCase( key ) ] = style[ key ];
            }
        }
    } else {
        for ( key in style ) {
            if ( typeof style[ key ] === "string" ) {
                newStyle[ key ] = style[ key ];
            }
        }
    }

    return newStyle;
}


function styleDifference( oldStyle, newStyle ) {
    var diff = {},
        name, value;

    for ( name in newStyle ) {
        value = newStyle[ name ];
        if ( oldStyle[ name ] !== value ) {
            if ( !shorthandStyles[ name ] ) {
                if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
                    diff[ name ] = value;
                }
            }
        }
    }

    return diff;
}

$.effects.animateClass = function( value, duration, easing, callback ) {
    var o = $.speed( duration, easing, callback );

    return this.queue( function() {
        var animated = $( this ),
            baseClass = animated.attr( "class" ) || "",
            applyClassChange,
            allAnimations = o.children ? animated.find( "*" ).andSelf() : animated;

        // map the animated objects to store the original styles.
        allAnimations = allAnimations.map(function() {
            var el = $( this );
            return {
                el: el,
                start: getElementStyles.call( this )
            };
        });

        // apply class change
        applyClassChange = function() {
            $.each( classAnimationActions, function(i, action) {
                if ( value[ action ] ) {
                    animated[ action + "Class" ]( value[ action ] );
                }
            });
        };
        applyClassChange();

        // map all animated objects again - calculate new styles and diff
        allAnimations = allAnimations.map(function() {
            this.end = getElementStyles.call( this.el[ 0 ] );
            this.diff = styleDifference( this.start, this.end );
            return this;
        });

        // apply original class
        animated.attr( "class", baseClass );

        // map all animated objects again - this time collecting a promise
        allAnimations = allAnimations.map(function() {
            var styleInfo = this,
                dfd = $.Deferred(),
                opts = jQuery.extend({}, o, {
                    queue: false,
                    complete: function() {
                        dfd.resolve( styleInfo );
                    }
                });

            this.el.animate( this.diff, opts );
            return dfd.promise();
        });

        // once all animations have completed:
        $.when.apply( $, allAnimations.get() ).done(function() {

            // set the final class
            applyClassChange();

            // for each animated element,
            // clear all css properties that were animated
            $.each( arguments, function() {
                var el = this.el;
                $.each( this.diff, function(key) {
                    el.css( key, '' );
                });
            });

            // this is guarnteed to be there if you use jQuery.speed()
            // it also handles dequeuing the next anim...
            o.complete.call( animated[ 0 ] );
        });
    });
};

$.fn.extend({
    _addClass: $.fn.addClass,
    addClass: function( classNames, speed, easing, callback ) {
        return speed ?
            $.effects.animateClass.call( this,
                { add: classNames }, speed, easing, callback ) :
            this._addClass( classNames );
    },

    _removeClass: $.fn.removeClass,
    removeClass: function( classNames, speed, easing, callback ) {
        return speed ?
            $.effects.animateClass.call( this,
                { remove: classNames }, speed, easing, callback ) :
            this._removeClass( classNames );
    },

    _toggleClass: $.fn.toggleClass,
    toggleClass: function( classNames, force, speed, easing, callback ) {
        if ( typeof force === "boolean" || force === undefined ) {
            if ( !speed ) {
                // without speed parameter
                return this._toggleClass( classNames, force );
            } else {
                return $.effects.animateClass.call( this,
                    (force ? { add: classNames } : { remove: classNames }),
                    speed, easing, callback );
            }
        } else {
            // without force parameter
            return $.effects.animateClass.call( this,
                { toggle: classNames }, force, speed, easing );
        }
    },

    switchClass: function( remove, add, speed, easing, callback) {
        return $.effects.animateClass.call( this, {
            add: add,
            remove: remove
        }, speed, easing, callback );
    }
});

})();

/******************************************************************************/
/*********************************** EFFECTS **********************************/
/******************************************************************************/

(function() {

$.extend( $.effects, {
    version: "1.9.2",

    // Saves a set of properties in a data storage
    save: function( element, set ) {
        for( var i=0; i < set.length; i++ ) {
            if ( set[ i ] !== null ) {
                element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
            }
        }
    },

    // Restores a set of previously saved properties from a data storage
    restore: function( element, set ) {
        var val, i;
        for( i=0; i < set.length; i++ ) {
            if ( set[ i ] !== null ) {
                val = element.data( dataSpace + set[ i ] );
                // support: jQuery 1.6.2
                // http://bugs.jquery.com/ticket/9917
                // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
                // We can't differentiate between "" and 0 here, so we just assume
                // empty string since it's likely to be a more common value...
                if ( val === undefined ) {
                    val = "";
                }
                element.css( set[ i ], val );
            }
        }
    },

    setMode: function( el, mode ) {
        if (mode === "toggle") {
            mode = el.is( ":hidden" ) ? "show" : "hide";
        }
        return mode;
    },

    // Translates a [top,left] array into a baseline value
    // this should be a little more flexible in the future to handle a string & hash
    getBaseline: function( origin, original ) {
        var y, x;
        switch ( origin[ 0 ] ) {
            case "top": y = 0; break;
            case "middle": y = 0.5; break;
            case "bottom": y = 1; break;
            default: y = origin[ 0 ] / original.height;
        }
        switch ( origin[ 1 ] ) {
            case "left": x = 0; break;
            case "center": x = 0.5; break;
            case "right": x = 1; break;
            default: x = origin[ 1 ] / original.width;
        }
        return {
            x: x,
            y: y
        };
    },

    // Wraps the element around a wrapper that copies position properties
    createWrapper: function( element ) {

        // if the element is already wrapped, return it
        if ( element.parent().is( ".ui-effects-wrapper" )) {
            return element.parent();
        }

        // wrap the element
        var props = {
                width: element.outerWidth(true),
                height: element.outerHeight(true),
                "float": element.css( "float" )
            },
            wrapper = $( "<div></div>" )
                .addClass( "ui-effects-wrapper" )
                .css({
                    fontSize: "100%",
                    background: "transparent",
                    border: "none",
                    margin: 0,
                    padding: 0
                }),
            // Store the size in case width/height are defined in % - Fixes #5245
            size = {
                width: element.width(),
                height: element.height()
            },
            active = document.activeElement;

        // support: Firefox
        // Firefox incorrectly exposes anonymous content
        // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
        try {
            active.id;
        } catch( e ) {
            active = document.body;
        }

        element.wrap( wrapper );

        // Fixes #7595 - Elements lose focus when wrapped.
        if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
            $( active ).focus();
        }

        wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element

        // transfer positioning properties to the wrapper
        if ( element.css( "position" ) === "static" ) {
            wrapper.css({ position: "relative" });
            element.css({ position: "relative" });
        } else {
            $.extend( props, {
                position: element.css( "position" ),
                zIndex: element.css( "z-index" )
            });
            $.each([ "top", "left", "bottom", "right" ], function(i, pos) {
                props[ pos ] = element.css( pos );
                if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
                    props[ pos ] = "auto";
                }
            });
            element.css({
                position: "relative",
                top: 0,
                left: 0,
                right: "auto",
                bottom: "auto"
            });
        }
        element.css(size);

        return wrapper.css( props ).show();
    },

    removeWrapper: function( element ) {
        var active = document.activeElement;

        if ( element.parent().is( ".ui-effects-wrapper" ) ) {
            element.parent().replaceWith( element );

            // Fixes #7595 - Elements lose focus when wrapped.
            if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
                $( active ).focus();
            }
        }


        return element;
    },

    setTransition: function( element, list, factor, value ) {
        value = value || {};
        $.each( list, function( i, x ) {
            var unit = element.cssUnit( x );
            if ( unit[ 0 ] > 0 ) {
                value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
            }
        });
        return value;
    }
});

// return an effect options object for the given parameters:
function _normalizeArguments( effect, options, speed, callback ) {

    // allow passing all options as the first parameter
    if ( $.isPlainObject( effect ) ) {
        options = effect;
        effect = effect.effect;
    }

    // convert to an object
    effect = { effect: effect };

    // catch (effect, null, ...)
    if ( options == null ) {
        options = {};
    }

    // catch (effect, callback)
    if ( $.isFunction( options ) ) {
        callback = options;
        speed = null;
        options = {};
    }

    // catch (effect, speed, ?)
    if ( typeof options === "number" || $.fx.speeds[ options ] ) {
        callback = speed;
        speed = options;
        options = {};
    }

    // catch (effect, options, callback)
    if ( $.isFunction( speed ) ) {
        callback = speed;
        speed = null;
    }

    // add options to effect
    if ( options ) {
        $.extend( effect, options );
    }

    speed = speed || options.duration;
    effect.duration = $.fx.off ? 0 :
        typeof speed === "number" ? speed :
        speed in $.fx.speeds ? $.fx.speeds[ speed ] :
        $.fx.speeds._default;

    effect.complete = callback || options.complete;

    return effect;
}

function standardSpeed( speed ) {
    // valid standard speeds
    if ( !speed || typeof speed === "number" || $.fx.speeds[ speed ] ) {
        return true;
    }

    // invalid strings - treat as "normal" speed
    if ( typeof speed === "string" && !$.effects.effect[ speed ] ) {
        // TODO: remove in 2.0 (#7115)
        if ( backCompat && $.effects[ speed ] ) {
            return false;
        }
        return true;
    }

    return false;
}

$.fn.extend({
    effect: function( /* effect, options, speed, callback */ ) {
        var args = _normalizeArguments.apply( this, arguments ),
            mode = args.mode,
            queue = args.queue,
            effectMethod = $.effects.effect[ args.effect ],

            // DEPRECATED: remove in 2.0 (#7115)
            oldEffectMethod = !effectMethod && backCompat && $.effects[ args.effect ];

        if ( $.fx.off || !( effectMethod || oldEffectMethod ) ) {
            // delegate to the original method (e.g., .show()) if possible
            if ( mode ) {
                return this[ mode ]( args.duration, args.complete );
            } else {
                return this.each( function() {
                    if ( args.complete ) {
                        args.complete.call( this );
                    }
                });
            }
        }

        function run( next ) {
            var elem = $( this ),
                complete = args.complete,
                mode = args.mode;

            function done() {
                if ( $.isFunction( complete ) ) {
                    complete.call( elem[0] );
                }
                if ( $.isFunction( next ) ) {
                    next();
                }
            }

            // if the element is hiddden and mode is hide,
            // or element is visible and mode is show
            if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
                done();
            } else {
                effectMethod.call( elem[0], args, done );
            }
        }

        // TODO: remove this check in 2.0, effectMethod will always be true
        if ( effectMethod ) {
            return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
        } else {
            // DEPRECATED: remove in 2.0 (#7115)
            return oldEffectMethod.call(this, {
                options: args,
                duration: args.duration,
                callback: args.complete,
                mode: args.mode
            });
        }
    },

    _show: $.fn.show,
    show: function( speed ) {
        if ( standardSpeed( speed ) ) {
            return this._show.apply( this, arguments );
        } else {
            var args = _normalizeArguments.apply( this, arguments );
            args.mode = "show";
            return this.effect.call( this, args );
        }
    },

    _hide: $.fn.hide,
    hide: function( speed ) {
        if ( standardSpeed( speed ) ) {
            return this._hide.apply( this, arguments );
        } else {
            var args = _normalizeArguments.apply( this, arguments );
            args.mode = "hide";
            return this.effect.call( this, args );
        }
    },

    // jQuery core overloads toggle and creates _toggle
    __toggle: $.fn.toggle,
    toggle: function( speed ) {
        if ( standardSpeed( speed ) || typeof speed === "boolean" || $.isFunction( speed ) ) {
            return this.__toggle.apply( this, arguments );
        } else {
            var args = _normalizeArguments.apply( this, arguments );
            args.mode = "toggle";
            return this.effect.call( this, args );
        }
    },

    // helper functions
    cssUnit: function(key) {
        var style = this.css( key ),
            val = [];

        $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
            if ( style.indexOf( unit ) > 0 ) {
                val = [ parseFloat( style ), unit ];
            }
        });
        return val;
    }
});

})();

/******************************************************************************/
/*********************************** EASING ***********************************/
/******************************************************************************/

(function() {

// based on easing equations from Robert Penner (http://www.robertpenner.com/easing)

var baseEasings = {};

$.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
    baseEasings[ name ] = function( p ) {
        return Math.pow( p, i + 2 );
    };
});

$.extend( baseEasings, {
    Sine: function ( p ) {
        return 1 - Math.cos( p * Math.PI / 2 );
    },
    Circ: function ( p ) {
        return 1 - Math.sqrt( 1 - p * p );
    },
    Elastic: function( p ) {
        return p === 0 || p === 1 ? p :
            -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
    },
    Back: function( p ) {
        return p * p * ( 3 * p - 2 );
    },
    Bounce: function ( p ) {
        var pow2,
            bounce = 4;

        while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
        return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
    }
});

$.each( baseEasings, function( name, easeIn ) {
    $.easing[ "easeIn" + name ] = easeIn;
    $.easing[ "easeOut" + name ] = function( p ) {
        return 1 - easeIn( 1 - p );
    };
    $.easing[ "easeInOut" + name ] = function( p ) {
        return p < 0.5 ?
            easeIn( p * 2 ) / 2 :
            1 - easeIn( p * -2 + 2 ) / 2;
    };
});

})();

})(jQuery));